package generic;

import java.util.ArrayList;

/**
 * Created with IntelliJ IDEA.
 * Description：
 * User：user
 * DATE:2021-11-14
 * Time:8:30
 */
/*
泛型只是在编译时期的一种机制，叫做擦除机制，会把泛型类当中的T擦除为Object，在运行的时候是没有泛型这个概念呢
作用：自动进行类型检查 自动进行类型的转换
<>只能是引用类型 不能是简单类型
一个泛型类可以实现一个泛型接口 comparable comparator

 */
class MyStack<T>{
    public T[] elem = (T[])new Object[2];//不能直接new T[]数组
    public  int usedSize;
    public void push(T val){
        this.elem[usedSize++] = val;
    }
    public T getTop(){
        return  this.elem[usedSize-1];
    }
}
//泛型边界问题
//写一个泛型类 找到泛型数组当中的最大值
//泛型的上界
class Alg<T extends  Comparable<T>>{//T object类没有实现接口
    //普通的泛型方法
    public T findMax(T[] array){
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0){
                //泛型数组存放的是引用类型，比较的时候必须要去实现comparable接口
                max = array[i];
            }
        }
        return  max;
    }
}
class A{

}

class GenericTest{
    public static<T> void print(ArrayList<T> list){
        for (T t:list) {
            System.out.println(t);
        }
    }

    public static void print2(ArrayList<?> list){//通配符的使用
        for (Object t:list) {
            System.out.println(t);
        }
    }
}
class Alg2{
    //泛型方法表示的是静态方法
    public static <T extends Comparable<T>> T findMax(T[] array){
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0){
                //泛型数组存放的是引用类型，比较的时候必须要去实现comparable接口
                max = array[i];
            }
        }
        return  max;
    }
}
public class Test {

    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        GenericTest.print(arrayList);
        GenericTest.print2(arrayList);
    }

    public static void main5(String[] args) {
        Integer[] array = {1,2,31,4};
        System.out.println(Alg2.findMax(array));
        System.out.println(Alg2.<Integer>findMax(array));
    }
    public static void main4(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Integer[] array = {1,2,3,4};
        System.out.println(alg.findMax(array));
    }

    public static void main3(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Alg<String> alg2 = new Alg<>();
        //Alg<A> alg3 = new Alg<A>();没有实现comparable接口
    }

    public static void main2(String[] args) {
        MyStack myStack = new MyStack();//不指定类型的话又可以随机放元素了
        myStack.push(1);
        myStack.push("1111");
    }
    public static void main1(String[] args) {
        MyStack<Integer> myStack = new MyStack<>();
        myStack.push(1);//自动进行类型检查
        int val = myStack.getTop();//自动进行类型转换
        MyStack<String> myStack1 = new MyStack<>();

    }
}
